package org.apache.solr.handler;

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import org.apache.commons.io.IOUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
import org.apache.lucene.util.Attribute;
import org.apache.lucene.util.AttributeReflector;
import org.apache.solr.common.SolrException;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.params.SolrParams;
import org.apache.solr.common.util.ContentStream;
import org.apache.solr.common.util.ContentStreamBase;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.common.util.SimpleOrderedMap;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.response.SolrQueryResponse;
import org.apache.solr.schema.FieldType;
import org.apache.solr.schema.IndexSchema;
import org.apache.solr.schema.SchemaField;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * 
 * @deprecated Use
 *             {@link org.apache.solr.handler.DocumentAnalysisRequestHandler}
 *             instead.
 **/
@Deprecated
public class AnalysisRequestHandler extends RequestHandlerBase {

	public static Logger log = LoggerFactory
			.getLogger(AnalysisRequestHandler.class);

	private XMLInputFactory inputFactory;

	@Override
	public void init(NamedList args) {
		super.init(args);

		inputFactory = XMLInputFactory.newInstance();
		try {
			// The java 1.6 bundled stax parser (sjsxp) does not currently have
			// a thread-safe
			// XMLInputFactory, as that implementation tries to cache and reuse
			// the
			// XMLStreamReader. Setting the parser-specific "reuse-instance"
			// property to false
			// prevents this.
			// All other known open-source stax parsers (and the bea ref impl)
			// have thread-safe factories.
			inputFactory.setProperty("reuse-instance", Boolean.FALSE);
		} catch (IllegalArgumentException ex) {
			// Other implementations will likely throw this exception since
			// "reuse-instance"
			// isimplementation specific.
			log.debug("Unable to set the 'reuse-instance' property for the input factory: "
					+ inputFactory);
		}
	}

	@Override
	public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp)
			throws Exception {
		SolrParams params = req.getParams();
		Iterable<ContentStream> streams = req.getContentStreams();
		if (streams != null) {
			for (ContentStream stream : req.getContentStreams()) {
				InputStream is = null;
				XMLStreamReader parser = null;
				try {
					is = stream.getStream();
					final String charset = ContentStreamBase
							.getCharsetFromContentType(stream.getContentType());
					parser = (charset == null) ? inputFactory
							.createXMLStreamReader(is) : inputFactory
							.createXMLStreamReader(is, charset);

					NamedList<Object> result = processContent(parser,
							req.getSchema());
					rsp.add("response", result);
				} finally {
					if (parser != null)
						parser.close();
					IOUtils.closeQuietly(is);
				}
			}
		}
	}

	NamedList<Object> processContent(XMLStreamReader parser, IndexSchema schema)
			throws XMLStreamException, IOException {
		NamedList<Object> result = new SimpleOrderedMap<Object>();
		while (true) {
			int event = parser.next();
			switch (event) {
			case XMLStreamConstants.END_DOCUMENT: {
				parser.close();
				return result;
			}
			case XMLStreamConstants.START_ELEMENT: {
				String currTag = parser.getLocalName();
				if ("doc".equals(currTag)) {
					log.trace("Tokenizing doc...");

					SolrInputDocument doc = readDoc(parser);
					SchemaField uniq = schema.getUniqueKeyField();
					NamedList<NamedList<NamedList<Object>>> theTokens = new SimpleOrderedMap<NamedList<NamedList<Object>>>();
					result.add(doc.getFieldValue(uniq.getName()).toString(),
							theTokens);
					for (String name : doc.getFieldNames()) {
						FieldType ft = schema.getFieldType(name);
						Analyzer analyzer = ft.getAnalyzer();
						Collection<Object> vals = doc.getFieldValues(name);
						for (Object val : vals) {
							Reader reader = new StringReader(val.toString());
							TokenStream tstream = analyzer.tokenStream(name,
									reader);
							NamedList<NamedList<Object>> tokens = getTokens(tstream);
							theTokens.add(name, tokens);
						}
					}
				}
				break;
			}
			}
		}
	}

	// a static mapping of the reflected attribute keys to the names used in
	// Solr 1.3/1.4
	static Map<String, String> ATTRIBUTE_MAPPING = Collections
			.unmodifiableMap(new HashMap<String, String>() {
				{
					put(CharTermAttribute.class.getName() + "#term", "value");
					put(OffsetAttribute.class.getName() + "#startOffset",
							"start");
					put(OffsetAttribute.class.getName() + "#endOffset", "end");
					put(PositionIncrementAttribute.class.getName()
							+ "#positionIncrement", "posInc");
					put(TypeAttribute.class.getName() + "#type", "type");
				}
			});

	static NamedList<NamedList<Object>> getTokens(TokenStream tstream)
			throws IOException {
		// outer is namedList since order of tokens is important
		NamedList<NamedList<Object>> tokens = new NamedList<NamedList<Object>>();

		while (tstream.incrementToken()) {
			final NamedList<Object> token = new SimpleOrderedMap<Object>();
			tokens.add("token", token);
			tstream.reflectWith(new AttributeReflector() {
				public void reflect(Class<? extends Attribute> attClass,
						String key, Object value) {
					String k = attClass.getName() + '#' + key;
					// map keys for "standard attributes":
					if (ATTRIBUTE_MAPPING.containsKey(k)) {
						k = ATTRIBUTE_MAPPING.get(k);
					}
					token.add(k, value);
				}
			});
		}
		return tokens;
	}

	SolrInputDocument readDoc(XMLStreamReader parser) throws XMLStreamException {
		SolrInputDocument doc = new SolrInputDocument();

		StringBuilder text = new StringBuilder();
		String name = null;
		String attrName = "";
		float boost = 1.0f;
		boolean isNull = false;
		while (true) {
			int event = parser.next();
			switch (event) {
			// Add everything to the text
			case XMLStreamConstants.SPACE:
			case XMLStreamConstants.CDATA:
			case XMLStreamConstants.CHARACTERS:
				text.append(parser.getText());
				break;

			case XMLStreamConstants.END_ELEMENT:
				if ("doc".equals(parser.getLocalName())) {
					return doc;
				} else if ("field".equals(parser.getLocalName())) {
					if (!isNull) {
						doc.addField(name, text.toString(), boost);
						boost = 1.0f;
					}
				}
				break;

			case XMLStreamConstants.START_ELEMENT:
				text.setLength(0);
				String localName = parser.getLocalName();
				if (!"field".equals(localName)) {
					log.warn("unexpected XML tag doc/" + localName);
					throw new SolrException(
							SolrException.ErrorCode.BAD_REQUEST,
							"unexpected XML tag doc/" + localName);
				}

				String attrVal = "";
				for (int i = 0; i < parser.getAttributeCount(); i++) {
					attrName = parser.getAttributeLocalName(i);
					attrVal = parser.getAttributeValue(i);
					if ("name".equals(attrName)) {
						name = attrVal;
					}
				}
				break;
			}
		}
	}

	// ////////////////////// SolrInfoMBeans methods //////////////////////
	@Override
	public String getDescription() {
		return "Provide Analysis of text";
	}

	@Override
	public String getVersion() {
		return "$Revision:$";
	}

	@Override
	public String getSourceId() {
		return "$Id:$";
	}

	@Override
	public String getSource() {
		return "$URL:$";
	}

}
